#include "dbq_getterror4module.h"
#include <QString>
#include <string>
#include "val2string.h"
#include "types.h"


namespace mysqlquery
{


//a++
inline enum etype operator++(enum etype et, int dummy)
{
  UNUSED_ARGUMENT(dummy);
  const int i = static_cast<int>(et);
  return static_cast<enum etype>(i + 1);
}

//++a
inline enum etype operator++(enum etype et)
{
  const int i = static_cast<int>(et);
  return static_cast<enum etype>(i + 1);
}


dbq_geterror4module::dbq_geterror4module(Module m)
{
  module_list.clear();
  module_list.push_back(m);
}

dbq_geterror4module::dbq_geterror4module(std::list<Module> m_list)
{
  module_list.clear();
  module_list = m_list;
}

dbq_geterror4module::~dbq_geterror4module()
{
}

void dbq_geterror4module::setModule(std::list<Module> m_list)
{
  module_list.clear();
  module_list = m_list;
}

void dbq_geterror4module::setModule(Module module)
{
  module_list.clear();
  module_list.push_back(module);
}

/********************************************************
*** The query waw written for select one module only. ***
*** for several modules the query must be updated *******
********************************************************/
QSqlQuery dbq_geterror4module::getSqlQuery()
{
  QString query = QString("SELECT error_code.*, module.module_name "
                          "FROM error_code, module "
                          "WHERE error_code.module_id = module.module_id");
  std::list<Module>::iterator it = module_list.begin();
  Module m = static_cast<Module>(*it);
  std::string str_module = tostring(m.getModuleID());

  query += " and error_code.module_id = " + QString(str_module.c_str());
  return QSqlQuery(query);
}












/******************************************************************************
*******************************************************************************
*******************************************************************************
*******************************************************************************/

dbquerygeterror::dbquerygeterror()
{
}

dbquerygeterror::~dbquerygeterror()
{
}


std::list<Errorcode> dbquerygeterror::getErrorList(ListQVariant lv)
{
  std::list<Errorcode>          ret_value;
  std::list<QVariant>::iterator qvariant_it;
  Errorcode                     error_code;
  enum etype                    next_type = ETYPE_ERROR_ID;

  for (qvariant_it = lv.begin() ; qvariant_it != lv.end(); qvariant_it++ )
  {
    QVariant qv = (QVariant)(*qvariant_it);

    if(next_type == ETYPE_ERROR_ID && qv.type() == QVariant::Int){
      error_code.setErrorID(qv.toInt());
      next_type = ETYPE_MODULE_ID;
    } else if(next_type == ETYPE_MODULE_ID && qv.type() == QVariant::Int){
      Module m = error_code.getModule();
      m.setModuleID(qv.toInt());
      error_code.setModule(m);
      next_type = ETYPE_ERROR_SHRT_DESCR;
    } else if(next_type == ETYPE_ERROR_SHRT_DESCR && qv.type() == QVariant::String){
      error_code.setShortDescription(qv.toString().toStdString());
      next_type = ETYPE_ERROR_FULL_DESCR;
    } else if(next_type == ETYPE_ERROR_FULL_DESCR && qv.type() == QVariant::String){
      error_code.setLongDescription(qv.toString().toStdString());
      next_type = ETYPE_ERROR_MODULE_NAME;
    } else if(next_type == ETYPE_ERROR_MODULE_NAME && qv.type() == QVariant::String){
      Module m = error_code.getModule();
      m.setModuleName(qv.toString().toStdString());
      error_code.setModule(m);
      next_type = ETYPE_MAX;
    } else { // ETYPE_MAX
      ret_value.push_back(error_code);
      error_code = Errorcode();
      error_code.setErrorID(qv.toInt());
      next_type = ETYPE_MODULE_ID;
    }
  }

/* the latest record must be added in the list*/
  if(next_type == ETYPE_MAX)
   ret_value.push_back(error_code);

  return ret_value;
}

} //mysqlquery
